/**
 * 导入导出相关的可组合函数
 * 
 * 该模块封装了与模板导入导出相关的功能，包括：
 * 1. 导出模板为JSON或图片
 * 2. 导入JSON模板
 * 3. 生成PDF等
 */

import { ElMessage, ElLoading } from 'element-plus';
import { jsPDF } from 'jspdf';
import html2canvas from 'html2canvas';
import { handleError, fileErrorHandler } from '../utils/errorHandling';
import { isCanvasReady } from '../utils/canvasUtils';

/**
 * 创建导入导出功能
 * @param {Object} options 配置选项
 * @param {Function} options.getTemplateData 获取模板数据的函数
 * @param {Function} options.loadTemplateData 加载模板数据的函数
 * @param {Function} options.clearCanvas 清空画布的函数
 * @param {Function} options.updateRulerDimensions 更新刻度尺尺寸的函数
 * @param {Number} options.pxPerMm 像素/毫米比例
 * @returns {Object} 导入导出相关的方法和属性
 */
export default function useExportImport(options = {}) {
  const {
    getTemplateData,
    loadTemplateData,
    clearCanvas,
    updateRulerDimensions,
    pxPerMm = 3.78 // 默认像素/毫米比例
  } = options;

  /**
   * 导出模板为JSON
   * @param {string} templateName 模板名称
   * @returns {Promise<boolean>} 操作成功标志
   */
  const exportJson = async (templateName) => {
    try {
      if (!isCanvasReady()) {
        throw new Error('画布未初始化');
      }
      
      const jsonData = getTemplateData();
      if (!jsonData) {
        throw new Error('获取模板数据失败');
      }
      
      // 创建下载链接
      const dataStr = "data:text/json;charset=utf-8," + encodeURIComponent(jsonData);
      const downloadAnchorNode = document.createElement('a');
      downloadAnchorNode.setAttribute("href", dataStr);
      downloadAnchorNode.setAttribute("download", `${templateName || 'template'}.json`);
      document.body.appendChild(downloadAnchorNode);
      downloadAnchorNode.click();
      downloadAnchorNode.remove();
      
      ElMessage.success('模板导出成功');
      return true;
    } catch (error) {
      fileErrorHandler(error, '导出JSON失败');
      return false;
    }
  };

  /**
   * 导入JSON模板
   * @returns {Promise<boolean>} 操作成功标志
   */
  const importJson = () => {
    return new Promise((resolve) => {
      try {
        if (!isCanvasReady()) {
          throw new Error('画布未初始化');
        }
        
        // 创建文件输入元素
        const fileInput = document.createElement('input');
        fileInput.type = 'file';
        fileInput.accept = '.json';
        fileInput.onchange = (event) => {
          const file = event.target.files[0];
          if (file) {
            const reader = new FileReader();
            reader.onload = (e) => {
              try {
                const jsonContent = e.target.result;
                
                // 清空当前画布
                clearCanvas();
                
                // 加载模板数据
                const success = loadTemplateData(jsonContent);
                
                if (success) {
                  
                  ElMessage.success('模板导入成功');
                  resolve(true);
                } else {
                  throw new Error('导入模板数据失败');
                }
              } catch (error) {
                fileErrorHandler(error, '读取JSON文件失败');
                resolve(false);
              }
            };
            reader.readAsText(file);
          } else {
            resolve(false);
          }
        };
        fileInput.click();
      } catch (error) {
        fileErrorHandler(error, '导入JSON失败');
        resolve(false);
      }
    });
  };

  /**
   * 将画布导出为图片并下载
   * @param {string} templateName 模板名称
   * @returns {Promise<boolean>} 操作成功标志
   */
  const downloadTemplate = async (templateName) => {
    try {
      if (!isCanvasReady()) {
        throw new Error('画布未初始化');
      }
      
      const loadingInstance = ElLoading.service({
        text: '正在导出模板...',
        background: 'rgba(0, 0, 0, 0.7)'
      });
      
      // 获取画布数据URL
      const dataURL = window.globalCanvas.toDataURL({
        format: 'png',
        quality: 1
      });
      
      // 创建下载链接
      const link = document.createElement('a');
      link.href = dataURL;
      link.download = `${templateName || 'template'}.png`;
      document.body.appendChild(link);
      link.click();
      document.body.removeChild(link);
      
      loadingInstance.close();
      ElMessage.success('模板导出成功');
      return true;
    } catch (error) {
      fileErrorHandler(error, '导出模板失败');
      return false;
    }
  };

  /**
   * 导出画布为PDF，保持准确的毫米比例
   * @param {string} templateName 模板名称
   * @param {Object} options 导出选项
   * @param {number} options.paperWidth 纸张宽度(mm)
   * @param {number} options.paperHeight 纸张高度(mm)
   * @returns {Promise<boolean>} 操作成功标志
   */
  const exportToPDF = async (templateName, { paperWidth, paperHeight } = {}) => {
    let loadingInstance = null;
    let fabricHighResCanvas = null;
    let highResCanvas = null;
    
    try {
      if (!isCanvasReady()) {
        throw new Error('画布未初始化');
      }

      loadingInstance = ElLoading.service({
        text: '正在生成高清PDF...',
        background: 'rgba(0, 0, 0, 0.7)'
      });

      console.log('开始PDF导出流程 - 画布准备就绪');
      
      // 获取画布的当前尺寸
      const canvas = window.globalCanvas;
      const canvasWidth = canvas.getWidth();
      const canvasHeight = canvas.getHeight();

      console.log(`画布尺寸: ${canvasWidth}x${canvasHeight}px`);

      // 使用当前画布的纸张尺寸（毫米）
      const widthMM = paperWidth || (canvasWidth / pxPerMm);
      const heightMM = paperHeight || (canvasHeight / pxPerMm);

      console.log(`纸张尺寸: ${widthMM}x${heightMM}mm, pxPerMm: ${pxPerMm}`);

      // 定义DPI和缩放因子提高输出质量
      const DPI = 300; // 标准打印质量
      const POINTS_PER_INCH = 72; // PDF中1英寸等于72点
      const MM_PER_INCH = 25.4; // 1英寸等于25.4毫米
      const qualityMultiplier = 3; // 使用更高的质量乘数
      
      // 创建jsPDF实例
      // 根据画布宽高比选择方向
      const orientation = widthMM > heightMM ? 'landscape' : 'portrait';
      
      // 创建PDF文档，使用自定义尺寸（毫米）
      const pdf = new jsPDF({
        orientation: orientation,
        unit: 'mm',
        format: [widthMM, heightMM],
        compress: true // 启用压缩以减小文件大小
      });

      // ========== 使用临时克隆画布进行高质量渲染 ==========
      loadingInstance.setText('创建临时画布进行高清渲染...');
      console.log('使用临时画布进行高清渲染...');
      
      try {
        // 计算内容边界，确保包含所有内容
        const contentBounds = calculateContentBounds(canvas);
        console.log('原始内容边界:', contentBounds);
        
        // 创建临时画布用于高质量渲染
        highResCanvas = document.createElement('canvas');
        highResCanvas.width = contentBounds.width * qualityMultiplier;
        highResCanvas.height = contentBounds.height * qualityMultiplier;
        
        // 防止在页面上可见，但需要它在DOM中以便正确渲染
      highResCanvas.style.position = 'absolute';
      highResCanvas.style.left = '-9999px';
      highResCanvas.style.top = '-9999px';
      document.body.appendChild(highResCanvas);
      
        // 创建临时Fabric画布
      fabricHighResCanvas = new window.fabric.Canvas(highResCanvas, {
          width: contentBounds.width * qualityMultiplier,
          height: contentBounds.height * qualityMultiplier,
          backgroundColor: canvas.backgroundColor || '#FFFFFF'
        });
        
        // 克隆原始画布的内容到临时画布
        const json = canvas.toJSON();
        
        // 处理所有对象的位置和尺寸
        json.objects.forEach(obj => {
          // 调整对象位置，考虑内容边界偏移
          obj.left = (obj.left - contentBounds.left) * qualityMultiplier;
          obj.top = (obj.top - contentBounds.top) * qualityMultiplier;
          
          // 调试信息
          const objType = obj.type || obj.customType || 'unknown';
          console.log(`处理对象: ${objType}, 原始缩放: scaleX=${obj.scaleX}, scaleY=${obj.scaleY}`);
          
          // 调整对象尺寸 - 保持宽高比一致
          const originalScaleX = obj.scaleX || 1;
          const originalScaleY = obj.scaleY || 1;
          
          // 确保X和Y方向的缩放比例相同
          if (originalScaleX !== originalScaleY) {
            // 统一使用X方向的缩放比例
            obj.scaleY = originalScaleX;
            console.log(`  - 调整缩放比例: 统一为 ${originalScaleX}`);
          }
          
          // 应用缩放因子
          obj.scaleX = originalScaleX * qualityMultiplier;
          obj.scaleY = originalScaleX * qualityMultiplier; // 使用相同的比例
          
          if (obj.strokeWidth) obj.strokeWidth *= qualityMultiplier;
          
          // 特殊处理文本对象 - 确保文本不会被截断且比例正确
          if ((obj.type === 'text' || obj.type === 'textbox') && obj.fontSize) {
            console.log(`  - 文本对象 "${obj.text || ''}", 原始尺寸: ${obj.width}x${obj.height}`);
            
            // 增加文本字体大小
            obj.fontSize *= qualityMultiplier;
            
            // 重置缩放，使用宽度和高度直接表示尺寸
            if (obj.width) {
              // 保存原始宽度和高度比例
              const aspectRatio = (obj.height || obj.fontSize * 1.2) / obj.width;
              console.log(`  - 文本宽高比: ${aspectRatio}`);
              
              // 设置新宽度
              obj.width *= qualityMultiplier;
              
              // 根据比例设置新高度
              obj.height = obj.width * aspectRatio;
              if (obj.customHeight) {
                obj.customHeight = obj.height;
              }
              
              // 重置缩放
              obj.scaleX = 1;
              obj.scaleY = 1;
              
              console.log(`  - 调整后尺寸: ${obj.width}x${obj.height}, 缩放: ${obj.scaleX}x${obj.scaleY}`);
            }
            
            // 确保文本对象有足够的宽度显示其内容
            if (obj.text && obj.text.length > 0 && (!obj.width || obj.width < 10)) {
              obj.width = obj.text.length * obj.fontSize * 0.6;
              obj.height = obj.fontSize * 1.2;
              if (obj.customHeight) {
                obj.customHeight = obj.height;
              }
            }
          }
          
          // 特殊处理表格对象
          if (obj.customType === 'table' || (obj.type === 'group' && obj.objects)) {
            console.log('处理表格对象尺寸调整:', obj);
            
            // 保存表格的原始缩放比例
            const tableScaleX = obj.scaleX || 1;
            const tableScaleY = obj.scaleY || 1;
            
            // 统一X和Y的缩放比例
            const tableUniformScale = Math.max(tableScaleX, tableScaleY);
            
            // 确保表格有足够空间，但不额外增加
            if (obj.width) {
              obj.width *= qualityMultiplier;
              obj.scaleX = 1; // 重置缩放，直接使用宽度
            }
            
            if (obj.height) {
              obj.height *= qualityMultiplier; 
              obj.scaleY = 1; // 重置缩放，直接使用高度
            }
            
            // 处理组内对象
            if (obj.objects) {
              console.log('  - 处理表格内部对象，数量:', obj.objects.length);
              
              obj.objects.forEach(subObj => {
                // 调整子对象位置
                if (subObj.left !== undefined) subObj.left *= qualityMultiplier;
                if (subObj.top !== undefined) subObj.top *= qualityMultiplier;
                
                // 统一子对象的缩放比例
                const subObjScaleX = subObj.scaleX || 1;
                const subObjScaleY = subObj.scaleY || 1;
                
                // 如果X和Y缩放不一致，使用最大值
                if (subObjScaleX !== subObjScaleY) {
                  const uniformScale = Math.max(subObjScaleX, subObjScaleY);
                  console.log(`  - 子对象缩放调整: ${subObjScaleX}x${subObjScaleY} -> ${uniformScale}x${uniformScale}`);
                  subObj.scaleX = uniformScale;
                  subObj.scaleY = uniformScale;
                }
                
                // 应用质量乘数
                subObj.scaleX *= qualityMultiplier;
                subObj.scaleY *= qualityMultiplier;
                
                if (subObj.strokeWidth) subObj.strokeWidth *= qualityMultiplier;
                
                // 特殊处理文本对象 - 增加文本容器宽度
                if ((subObj.type === 'text' || subObj.type === 'textbox') && subObj.fontSize) {
                  console.log(`  - 表格单元格文本: "${subObj.text || ''}", 原始尺寸: ${subObj.width}x${subObj.height}`);
                  
                  // 增加文本字体大小
                  subObj.fontSize *= qualityMultiplier;
                  
                  // 重置缩放，使用宽度和高度直接表示尺寸
                  if (subObj.width) {
                    // 保存原始宽度和高度比例
                    const aspectRatio = (subObj.height || subObj.fontSize * 1.2) / subObj.width;
                    
                    // 设置新宽度
                    subObj.width *= qualityMultiplier;
                    
                    // 根据比例设置新高度
                    subObj.height = subObj.width * aspectRatio;
                    if (subObj.customHeight) {
                      subObj.customHeight = subObj.height;
                    }
                    
                    // 重置缩放
                    subObj.scaleX = 1;
                    subObj.scaleY = 1;
                  }
                  
                  // 确保文本对象有足够的宽度显示其内容
                  if (subObj.text && subObj.text.length > 0 && (!subObj.width || subObj.width < 10)) {
                    subObj.width = subObj.text.length * subObj.fontSize * 0.6;
                    subObj.height = subObj.fontSize * 1.2;
                    if (subObj.customHeight) {
                      subObj.customHeight = subObj.height;
                    }
                  }
                }
              });
            }
          }
        });
        
        // 加载调整后的JSON到临时画布
        fabricHighResCanvas.loadFromJSON(json, function() {
          console.log('JSON已加载到临时高分辨率画布');
          
          // 获取所有加载的对象
          const loadedObjects = fabricHighResCanvas.getObjects();
          console.log(`已加载 ${loadedObjects.length} 个对象`);
          
          // 特殊处理表格和文本对象
          loadedObjects.forEach(obj => {
            if (obj.type === 'group' && obj._objects) {
              console.log('加载后处理表格:', obj);
              
              // 确保表格组的所有子对象都显示完整
              obj._objects.forEach(cellObj => {
                if (cellObj.type === 'text' || cellObj.type === 'textbox') {
                  // 特殊处理单元格中的文本
                  if (cellObj.text && cellObj.text.length > 0) {
                    // 确保文本可见且完整
                    cellObj.visible = true;
                    cellObj.opacity = 1;
                    
                    // 输出文本对象当前的缩放和尺寸
                    console.log(`表格单元格文本[${cellObj.text}]: scaleX=${cellObj.scaleX}, scaleY=${cellObj.scaleY}, width=${cellObj.width}, height=${cellObj.height}`);
                    
                    // 保持文本宽高比例一致
                    if (cellObj.scaleY !== cellObj.scaleX) {
                      // 使用最大的缩放比例确保文本显示完整
                      const maxScale = Math.max(cellObj.scaleX, cellObj.scaleY);
                      console.log(`  - 调整缩放: ${cellObj.scaleX}x${cellObj.scaleY} -> ${maxScale}x${maxScale}`);
                      
                      // 设置统一的缩放比例
                      cellObj.scaleX = maxScale;
                      cellObj.scaleY = maxScale;
                      
                      // 如果有自定义高度，也修正比例
                      if (cellObj.customHeight) {
                        cellObj.customHeight = cellObj.height * maxScale;
                      }
                      
                      // 标记为需要重新渲染
                      cellObj.dirty = true;
                    }
                  }
                }
              });
              
              // 调整整个表格的宽高比例以确保不被拉伸
              const originalBounds = obj.getBoundingRect(true, true);
              console.log('表格加载后尺寸:', originalBounds);
            }
          });
          
          fabricHighResCanvas.renderAll();
        });
        
        // 等待渲染完成
        await new Promise(resolve => setTimeout(resolve, 300));
        
        // 渲染临时高分辨率画布
        loadingInstance.setText('正在生成高清图像...');
        fabricHighResCanvas.renderAll();
        
        // 获取高分辨率图像数据
        const highResDataURL = fabricHighResCanvas.toDataURL({
          format: 'png',
          quality: 1.0
        });
        
        // 将图片添加到PDF
        loadingInstance.setText('正在创建PDF...');
        
        // 创建临时图像对象，用于获取实际图像比例
        const img = new Image();
        img.src = highResDataURL;
        
        // 等待图像加载完成
        await new Promise((resolve, reject) => {
          img.onload = resolve;
          img.onerror = reject;
        });
        
        console.log(`图像尺寸: ${img.width}x${img.height}px, PDF尺寸: ${widthMM}x${heightMM}mm`);
        
        // 计算图像比例和PDF比例
        const imgRatio = img.width / img.height;
        const pdfRatio = widthMM / heightMM;
        
        // 调整PDF尺寸以匹配图像比例，避免拉伸
        let finalWidth = widthMM;
        let finalHeight = heightMM;
        
        // 如果比例不匹配，计算新尺寸，保持比例一致
        if (Math.abs(imgRatio - pdfRatio) > 0.01) { // 允许1%的误差
          console.log('图像比例与PDF比例不匹配，调整PDF尺寸以保持比例');
          // 以宽度为基准，调整高度
          finalHeight = finalWidth / imgRatio;
          console.log(`调整后的PDF尺寸: ${finalWidth}x${finalHeight}mm`);
        }
        
        // 使用图像尺寸和调整后的内容比例创建精确的PDF
        pdf.addImage(highResDataURL, 'PNG', 0, 0, finalWidth, finalHeight, undefined, 'FAST');
        
        // 清理临时画布资源
        if (fabricHighResCanvas) {
            fabricHighResCanvas.dispose();
            fabricHighResCanvas = null;
        }
        
        if (highResCanvas && highResCanvas.parentNode) {
            highResCanvas.parentNode.removeChild(highResCanvas);
            highResCanvas = null;
        }
        
        // 保存PDF
        pdf.save(`${templateName || 'template'}.pdf`);
        
        if (loadingInstance) {
          loadingInstance.close();
          loadingInstance = null;
        }
        
        ElMessage.success('高清PDF导出成功');
        return true;
      } catch (renderError) {
        console.error('高清渲染失败，尝试备选方法：', renderError);
        
        // 清理临时资源
        if (fabricHighResCanvas) {
          try {
            fabricHighResCanvas.dispose();
            fabricHighResCanvas = null;
          } catch (e) {}
        }
        
        if (highResCanvas && highResCanvas.parentNode) {
          try {
            highResCanvas.parentNode.removeChild(highResCanvas);
            highResCanvas = null;
          } catch (e) {}
        }
        
        // 回退到基本导出方法
        return exportWithBasicMethod(canvas, pdf, templateName, {
          widthMM, 
          heightMM,
          loadingInstance
        });
      }
    } catch (error) {
      console.error('导出PDF失败:', error);
      
      // 确保资源得到清理
      if (fabricHighResCanvas) {
        try {
          fabricHighResCanvas.dispose();
        } catch (e) {}
      }
      
      if (highResCanvas && highResCanvas.parentNode) {
        try {
          highResCanvas.parentNode.removeChild(highResCanvas);
        } catch (e) {}
      }
      
      if (loadingInstance) {
        loadingInstance.close();
      }
      
      fileErrorHandler(error, '导出PDF失败');
      return false;
    }
  };

  // 添加基本导出方法作为备选
  const exportWithBasicMethod = async (canvas, pdf, templateName, options) => {
    const { widthMM, heightMM, loadingInstance } = options;
    
    try {
      loadingInstance.setText('使用基本方法导出...');
      console.log('使用基本导出方法');
      
      // 使用简单的方法导出画布
      const dataURL = canvas.toDataURL({
        format: 'png',
        quality: 1.0,
        multiplier: 2 // 使用较小的乘数以确保性能
      });
      
      // 创建临时图像对象，用于获取实际图像比例
      const img = new Image();
      img.src = dataURL;
      
      // 等待图像加载完成
      await new Promise((resolve, reject) => {
        img.onload = resolve;
        img.onerror = reject;
      });
      
      // 计算图像比例和PDF比例
      const imgRatio = img.width / img.height;
      const pdfRatio = widthMM / heightMM;
      
      // 调整PDF尺寸以匹配图像比例，避免拉伸
      let finalWidth = widthMM;
      let finalHeight = heightMM;
      
      // 如果比例不匹配，计算新尺寸，保持比例一致
      if (Math.abs(imgRatio - pdfRatio) > 0.01) { // 允许1%的误差
        // 以宽度为基准，调整高度
        finalHeight = finalWidth / imgRatio;
      }
      
      // 将图片添加到PDF
      pdf.addImage(dataURL, 'PNG', 0, 0, finalWidth, finalHeight);
      pdf.save(`${templateName || 'template'}.pdf`);
      
      if (loadingInstance) {
        loadingInstance.close();
      }
      
      ElMessage.success('PDF导出成功 (使用基本方法)');
      return true;
    } catch (error) {
      console.error('基本导出方法失败:', error);
      
      if (loadingInstance) {
        loadingInstance.close();
      }
      
      fileErrorHandler(error, '导出PDF失败');
      return false;
    }
  };

  // 修改计算内容边界的函数，大幅增加边距
  const calculateContentBounds = (canvas) => {
    const objects = canvas.getObjects();
    if (!objects || objects.length === 0) {
      return { left: 0, top: 0, width: canvas.getWidth(), height: canvas.getHeight() };
    }
    
    // 初始化边界值
    let minX = Number.MAX_VALUE;
    let minY = Number.MAX_VALUE;
    let maxX = Number.MIN_VALUE;
    let maxY = Number.MIN_VALUE;
    
    // 存储所有发现的表格，用于单独处理
    const tables = [];
    
    // 第一遍扫描 - 查找所有对象的边界
    objects.forEach(obj => {
      if (!obj.visible) return;
      
      // 识别表格对象
      if (obj.customType === 'table' || 
          (obj.type === 'group' && obj._objects && 
           obj._objects.length > 0)) {
        tables.push(obj);
      }
      
      const objBounds = obj.getBoundingRect(true, true);
      minX = Math.min(minX, objBounds.left);
      minY = Math.min(minY, objBounds.top);
      maxX = Math.max(maxX, objBounds.left + objBounds.width);
      maxY = Math.max(maxY, objBounds.top + objBounds.height);
    });
    
    // 第二遍扫描 - 对表格进行特殊处理
    tables.forEach(table => {
      console.log('特殊处理表格对象:', table);
      
      // 确保表格边界有足够大的边距
      const tableBounds = table.getBoundingRect(true, true);
      console.log('表格原始边界:', tableBounds);
      
      // 为表格增加额外的边距
      const tableExtraPadding = 50; // 为表格增加更大的边距
      minX = Math.min(minX, tableBounds.left - tableExtraPadding);
      minY = Math.min(minY, tableBounds.top - tableExtraPadding);
      maxX = Math.max(maxX, tableBounds.left + tableBounds.width + tableExtraPadding);
      maxY = Math.max(maxY, tableBounds.top + tableBounds.height + tableExtraPadding);
      
      // 处理表格内的所有子对象
      if (table._objects) {
        table._objects.forEach(cellObj => {
          if (!cellObj.visible) return;
          
          // 获取单元格的边界
          try {
            const cellBounds = cellObj.getBoundingRect(false, true);
            console.log('单元格边界:', cellBounds);
            
            // 为每个单元格也增加更大的边距
            const cellPadding = 20;
            minX = Math.min(minX, cellBounds.left - cellPadding);
            minY = Math.min(minY, cellBounds.top - cellPadding);
            maxX = Math.max(maxX, cellBounds.left + cellBounds.width + cellPadding);
            maxY = Math.max(maxY, cellBounds.top + cellBounds.height + cellPadding);
            
            // 特殊处理单元格内的文本对象
            if (cellObj.type === 'text' || cellObj.type === 'textbox') {
              // 文本对象需要更大的额外边距
              const textPadding = 30;
              minX = Math.min(minX, cellBounds.left - textPadding);
              minY = Math.min(minY, cellBounds.top - textPadding);
              maxX = Math.max(maxX, cellBounds.left + cellBounds.width + textPadding);
              maxY = Math.max(maxY, cellBounds.top + cellBounds.height + textPadding);
            }
          } catch (e) {
            console.error('处理单元格边界时出错:', e);
          }
        });
      }
    });
    
    // 如果没有可见对象，使用画布尺寸
    if (minX === Number.MAX_VALUE) {
      return { left: 0, top: 0, width: canvas.getWidth(), height: canvas.getHeight() };
    }
    
    // 添加更大的通用边距确保内容不会被截断
    const generalPadding = 100; // 大幅增加通用边距
    minX = Math.max(0, minX - generalPadding);
    minY = Math.max(0, minY - generalPadding);
    maxX = Math.min(canvas.getWidth(), maxX + generalPadding);
    maxY = Math.min(canvas.getHeight(), maxY + generalPadding);
    
    // 计算最终尺寸并设置最小尺寸
    const width = Math.max(maxX - minX, canvas.getWidth() * 0.8); // 确保宽度至少为画布的80%
    const height = Math.max(maxY - minY, canvas.getHeight() * 0.8); // 确保高度至少为画布的80%
    
    const result = {
      left: minX,
      top: minY,
      width: width,
      height: height
    };
    
    console.log('计算的最终内容边界:', result);
    return result;
  };

  return {
    exportJson,
    importJson,
    downloadTemplate,
    exportToPDF
  };
}
